﻿using System;
using System.Data.Linq;
using System.Linq;
using AutoMapper;
using Bootstrap.AutoMapper;
using Dogshow.Model;

namespace Dogshow.Linq2SQLRepository
{
    public class ModelMapper : Profile
    {

        protected override void Configure()
        {
            CreateMap<Titula, Model.Titula>();
            CreateMap<Model.Titula, Titula>()
                .ForMember(x => x.TitulePasas, opt => opt.Ignore())
                .ForMember(x => x.TituleIzlozbes, opt => opt.Ignore());

            CreateMap<RasePasa, RasaPsa>()
                .ForMember(x => x.FciGrupa, opt => opt.MapFrom(x => x.FCIGrupe))
                .ForMember(x => x.Status, opt => opt.Ignore());
            CreateMap<RasaPsa, RasePasa>()
                .ForMember(x => x.FCIGrupe, opt => opt.Ignore());

            CreateMap<Model.Kinolog, Kinolozi>()
                .ForMember(x => x.Status, opt => opt.MapFrom(x => (int) x.VrstaKinologa));

            CreateMap<Kinolozi, Model.Kinolog>()
                .ForMember(x => x.VrstaKinologa, opt => opt.MapFrom(x => Enum.ToObject(typeof(VrstaKinologa), x.Status)))
                .ForMember(x => x.ImeIPrezime, opt => opt.MapFrom(x => x.Korisnicis.Naziv))
                .ForMember(x => x.Telefon, opt => opt.MapFrom(x => x.Korisnicis.Telefon))
                .ForMember(x => x.Adresa, opt => opt.MapFrom(x => x.Korisnicis.Adresa))
                .ForMember(x => x.IdMesta, opt => opt.MapFrom(x => x.Korisnicis.IdMesta))
                .ForMember(x => x.Mesto, opt => opt.MapFrom(x => x.Korisnicis.Mesta));

            CreateMap<Model.Pas, Psi>()
                .ForMember(x => x.RasePasa, opt => opt.Ignore())
                .ForMember(x => x.Kinolozi, opt => opt.Ignore())
                .ForMember(x => x.Psi1, opt => opt.Ignore())
                .ForMember(x => x.Psi2, opt => opt.Ignore())
                .ForMember(x => x.Kinolozi1, opt => opt.Ignore());

            CreateMap<Psi, Model.Pas>()
                //.ForMember(x => x.SlikaPsa, opt => opt.ResolveUsing(p => p.SlikaPsa != null ? p.SlikaPsa.ToArray() : null))
                //.ForMember(x => x.Vlasnik, opt => opt.MapFrom(x => x.Kinolozi1))
                //.ForMember(x => x.Titule, opt => opt.MapFrom(x => x.TitulePasas))
                //.ForMember(x => x.Otac, opt => opt.MapFrom(x => x.Psi2))
                //.ForMember(x => x.Majka, opt => opt.MapFrom(x => x.Psi1))
                //.ForMember(x => x.Odgajivac, opt => opt.MapFrom(x => x.Kinolozi))
                .ForMember(x => x.RasaPsa, opt => opt.MapFrom(x => x.RasePasa));

            CreateMap<Model.TitulaPsa, TitulePasa>()
                .ForMember(x => x.Psi, opt => opt.Ignore())
                .ForMember(x => x.Titula, opt => opt.Ignore());
                
            CreateMap<TitulePasa, Model.TitulaPsa>();

            CreateMap<Psi, InfoOPsu>()
                .ForMember(x => x.Rasa, opt => opt.MapFrom(x => x.RasePasa.NazivRase))
                .ForMember(x => x.FciGrupa, opt => opt.MapFrom(x => x.RasePasa.FCIGrupe));

            CreateMap<FCIGrupe, FciGrupa>();
            CreateMap<FciGrupa, FCIGrupe>();

            CreateMap<Mesta, Mesto>();
            CreateMap<Mesto, Mesta>();

            CreateMap<KinoloskaDrustva, KinoloskoDrustvo>()
                .ForMember(x => x.Mesto, opt => opt.MapFrom(x => x.Mesta));
            CreateMap<KinoloskoDrustvo, KinoloskaDrustva>()
                .ForMember(x => x.Mesta, opt => opt.Ignore());

            CreateMap<Izlozbe, Izlozba>()
                .ForMember(x => x.Titule, opt => opt.Ignore())
                .ForMember(x => x.Organizator, opt => opt.MapFrom(x => x.KinoloskaDrustva));
            CreateMap<Izlozba, Izlozbe>()
                .ForMember(x => x.KinoloskaDrustva, opt => opt.Ignore());

            CreateMap<RasporedRingova, SudijaURingu>()
                .ForMember(x => x.ImeSudije, opt => opt.MapFrom(x => x.Kinolozi.Korisnicis.Naziv));
            CreateMap<SudijaURingu, RasporedRingova>();

            CreateMap<RasePoRingovima, RasaURingu>()
                .ForMember(x => x.NazivRase, opt => opt.MapFrom(x => x.RasePasa.NazivRase));
            CreateMap<RasaURingu, RasePoRingovima>()
                .ForMember(x => x.RasporedRingova, opt => opt.Ignore())
                .ForMember(x => x.RasePasa, opt => opt.Ignore());

            CreateMap<Korisnici, Korisnik>()
                .ForMember(x => x.Lozinka, opt => opt.MapFrom(x => x.Lozinka.ToArray()))
                .ForMember(x => x.VidljivaLozinka, opt => opt.UseValue("***************"));

            CreateMap<Korisnik, Korisnici>()
                .ForMember(x => x.Lozinka, opt => opt.MapFrom(x => x.Lozinka))
                .ForMember(x => x.IdKinoloskogDrustva, opt => opt.UseValue(null));

            CreateMap<Korisnici, Administrator>()
                .ForMember(x => x.Lozinka, opt => opt.MapFrom(x => x.Lozinka.ToArray()))
                .ForMember(x => x.VidljivaLozinka, opt => opt.UseValue("***************"));
            CreateMap<Korisnici, KorisnikKinoloskoDrustvo>()
                .ForMember(x => x.Lozinka, opt => opt.MapFrom(x => x.Lozinka.ToArray()))
                .ForMember(x => x.VidljivaLozinka, opt => opt.UseValue("***************"));
            CreateMap<KorisnikKinoloskoDrustvo, Korisnici>()
                .ForMember(x => x.Lozinka, opt => opt.MapFrom(x => new Binary(x.Lozinka)))
                .ForMember(x => x.IdKinoloskogDrustva, opt => opt.MapFrom(x => x.IdKinoloskogDrustva));
        }

        #region Titule
        public static Titula Map(Model.Titula titula)
        {
            return Mapper.Map<Model.Titula, Titula>(titula);
        }

        public static Model.Titula Map(Titula titula)
        {
            return Mapper.Map<Titula, Model.Titula>(titula);
        }

        public static void Map(Model.Titula titula, Titula existing)
        {
            Mapper.Map(titula, existing);
        }

        public static void Map(Titula titula, Model.Titula existing)
        {
            Mapper.Map(titula, existing);
        }

        public static TitulaPsa Map(TitulePasa titula)
        {
            return Mapper.Map<TitulePasa, TitulaPsa>(titula);
        }
        #endregion

        #region RasaPsa
        public static RasaPsa Map(RasePasa rasa)
        {
            return Mapper.Map<RasePasa, RasaPsa>(rasa);
        }

        public static RasePasa Map(RasaPsa rasa)
        {
            return Mapper.Map<RasaPsa, RasePasa>(rasa);
        }

        public static void Map(RasaPsa rasa, RasePasa existing)
        {
            Mapper.Map(rasa, existing);
        }

        public static void Map(RasePasa rasa, RasaPsa existing)
        {
            Mapper.Map(rasa, existing);
        }
        #endregion

        #region Kinolog

        public static Kinolozi Map(Model.Kinolog kinolog)
        {
            return Mapper.Map<Model.Kinolog, Kinolozi>(kinolog);
        }

        public static Model.Kinolog Map(Kinolozi kinolog)
        {
            return Mapper.Map<Kinolozi, Model.Kinolog>(kinolog);
        }

        public static void Map(Model.Kinolog kinolog, Kinolozi existing)
        {
            Mapper.Map(kinolog, existing);
        }

        public static void Map(Kinolozi kinolog, Model.Kinolog existing)
        {
            Mapper.Map(kinolog, existing);
        }
        #endregion

        #region Psi
        public static Psi Map(Model.Pas pas)
        {
            return Mapper.Map<Model.Pas, Psi>(pas);
        }

        public static Model.Pas Map(Psi pas)
        {
            return Mapper.Map<Psi, Model.Pas>(pas);
        }

        public static void Map(Model.Pas from, Psi to)
        {
            Mapper.Map(from, to);
        }

        public static void Map(Psi from, Model.Pas to)
        {
            Mapper.Map(from, to);
        }
        public static InfoOPsu MapirajInfoOPsu(Psi pas)
        {
            return Mapper.Map<Psi, InfoOPsu>(pas);
        }
        #endregion

        #region Titule psa
        public static TitulePasa Map(Model.TitulaPsa titula)
        {
            return Mapper.Map<Model.TitulaPsa, TitulePasa>(titula);
        }
        #endregion

        #region FCI grupe
        public static FciGrupa Map(FCIGrupe grupa)
        {
            return Mapper.Map<FCIGrupe, FciGrupa>(grupa);
        }
        #endregion

        #region Mesta
        public static Mesta Map(Mesto mesto)
        {
            return Mapper.Map<Mesto, Mesta>(mesto);
        }

        public static Mesto Map(Mesta mesto)
        {
            return Mapper.Map<Mesta, Mesto>(mesto);
        }

        public static void Map(Mesto from, Mesta to)
        {
            Mapper.Map(from, to);
        }
        #endregion

        #region Kinoloska drustva
        public static KinoloskoDrustvo Map(KinoloskaDrustva kinoloskoDrustvo)
        {
            return Mapper.Map<KinoloskaDrustva, KinoloskoDrustvo>(kinoloskoDrustvo);
        }

        public static KinoloskaDrustva Map(KinoloskoDrustvo kinoloskoDrustvo)
        {
            return Mapper.Map<KinoloskoDrustvo, KinoloskaDrustva>(kinoloskoDrustvo);
        }

        public static void Map(KinoloskoDrustvo from, KinoloskaDrustva to)
        {
            Mapper.Map(from, to);
        }
        #endregion

        #region Izlozbe
        public static Izlozba Map(Izlozbe izlozba)
        {
            return Mapper.Map<Izlozbe, Izlozba>(izlozba);
        }
        public static Izlozbe Map(Izlozba izlozba)
        {
            return Mapper.Map<Izlozba, Izlozbe>(izlozba);
        }
        public static void Map(Izlozba from, Izlozbe to)
        {
            Mapper.Map(from, to);
        }

        public static SudijaURingu Map(RasporedRingova raspored)
        {
            return Mapper.Map<RasporedRingova, SudijaURingu>(raspored);
        }

        public static RasporedRingova Map(SudijaURingu sudijaURingu)
        {
            return Mapper.Map<SudijaURingu, RasporedRingova>(sudijaURingu);
        }

        public static void Map(SudijaURingu from, RasporedRingova to)
        {
            Mapper.Map(from, to);
        }

        public static RasaURingu Map(RasePoRingovima from)
        {
            return Mapper.Map<RasePoRingovima, RasaURingu>(from);
        }

        public static RasePoRingovima Map(RasaURingu from)
        {
            return Mapper.Map<RasaURingu, RasePoRingovima>(from);
        }

        public static void Map(RasaURingu from, RasePoRingovima to)
        {
            Mapper.Map(from, to);
        }
        #endregion

        #region Korisnici
        public static Korisnik Map(Korisnici from)
        {
            if (from.VrstaKorisnika == 1)
            {
                return Mapper.Map<Korisnici, Administrator>(from);
            }
            if (from.VrstaKorisnika == 2)
            {
                return Mapper.Map<Korisnici, Korisnik>(from);    
            }
            return Mapper.Map<Korisnici, KorisnikKinoloskoDrustvo>(from);
        }

        public static Korisnici Map(Korisnik from)
        {
            return Mapper.Map<Korisnik, Korisnici>(from);
        }

        public static void Map(Korisnik from, Korisnici to)
        {
            Mapper.Map(from, to);
        }

        public static void Map(KorisnikKinoloskoDrustvo from, Korisnici to)
        {
            Mapper.Map(from, to);
        }
        #endregion
    }
}